import pytest  # used for our unit tests
from codeflash.bubble_sort import sorter

# unit tests

@pytest.mark.parametrize("input_list, expected_output", [
    # Basic Functionality
    ([3, 1, 2], [1, 2, 3]),  # simple unsorted list
    ([5, 4, 3, 2, 1], [1, 2, 3, 4, 5]),  # reverse sorted list
    ([1, 2, 3], [1, 2, 3]),  # already sorted list
    ([1, 2, 3, 4, 5], [1, 2, 3, 4, 5]),  # already sorted list
    ([3, 2, 1], [1, 2, 3]),  # reverse sorted list
    
    # Edge Cases
    ([], []),  # empty list
    ([1], [1]),  # single element list
    ([2, 1], [1, 2]),  # two elements unsorted
    ([1, 2], [1, 2]),  # two elements sorted
    
    # Lists with Duplicates
    ([1, 1, 1], [1, 1, 1]),  # all elements same
    ([3, 1, 2, 2, 1], [1, 1, 2, 2, 3]),  # some elements same
    ([4, 5, 4, 3, 3, 2, 1], [1, 2, 3, 3, 4, 4, 5]),  # some elements same
    
    # Lists with Negative Numbers
    ([-1, -3, -2, 0, 2, 1], [-3, -2, -1, 0, 1, 2]),  # negative and positive numbers
    ([-3, -1, -2], [-3, -2, -1]),  # all negative numbers
    
    # Lists with Mixed Data Types
    ([1.1, 2.2, 0.5, 3], [0.5, 1.1, 2.2, 3]),  # integers and floats
    ([3, 1.5, 2.5, 1], [1, 1.5, 2.5, 3]),  # integers and floats
    
    # Large Scale Test Cases
    (list(range(1000, 0, -1)), list(range(1, 1001))),  # large list in reverse order
    (list(range(10000, 9000, -1)), list(range(1, 1001))),  # very large list in reverse order
    
    # Performance and Scalability
    (list(range(100000, 99000, -1)), list(range(1, 1001))),  # very large list in reverse order
])
def test_sorter(input_list, expected_output):
    # Test the sorter function with various inputs and expected outputs
    codeflash_output = sorter(input_list)
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.

import pytest  # used for our unit tests
from codeflash.bubble_sort import sorter

# unit tests

# Basic Functionality Tests
def test_basic_unsorted_list():
    codeflash_output = sorter([3, 1, 2])
    codeflash_output = sorter([5, 3, 8, 6, 2])

def test_basic_sorted_list():
    codeflash_output = sorter([1, 2, 3])
    codeflash_output = sorter([2, 4, 6, 8, 10])

def test_basic_reverse_sorted_list():
    codeflash_output = sorter([3, 2, 1])
    codeflash_output = sorter([10, 8, 6, 4, 2])

# Edge Case Tests
def test_single_element_list():
    codeflash_output = sorter([1])
    codeflash_output = sorter([42])

def test_empty_list():
    codeflash_output = sorter([])

def test_all_elements_same():
    codeflash_output = sorter([2, 2, 2])
    codeflash_output = sorter([5, 5, 5, 5, 5])

# Lists with Negative Numbers
def test_mixed_positive_and_negative_numbers():
    codeflash_output = sorter([3, -1, 2, -2])
    codeflash_output = sorter([0, -3, 5, -2, 4])

def test_all_negative_numbers():
    codeflash_output = sorter([-3, -1, -2])
    codeflash_output = sorter([-5, -3, -8, -6, -2])

# Lists with Floating Point Numbers
def test_mixed_integers_and_floats():
    codeflash_output = sorter([3.1, 2.2, 1.3])
    codeflash_output = sorter([5, 3.5, 8.1, 6.2, 2])

def test_all_floats():
    codeflash_output = sorter([3.3, 1.1, 2.2])
    codeflash_output = sorter([5.5, 3.3, 8.8, 6.6, 2.2])

# Large Scale Test Cases
def test_large_list():
    large_list = list(range(1000, 0, -1))
    sorted_large_list = list(range(1, 1001))
    codeflash_output = sorter(large_list)

def test_large_performance():
    large_list = list(range(10000, 9000, -1))
    sorted_large_list = list(range(1, 1001))
    codeflash_output = sorter(large_list)

# Lists with Duplicates
def test_list_with_duplicates():
    codeflash_output = sorter([3, 1, 2, 1])
    codeflash_output = sorter([5, 3, 8, 3, 2, 2])

# Lists with Mixed Data Types (if applicable)
def test_mixed_data_types():
    with pytest.raises(TypeError):
        sorter([3, '1', 2])
    with pytest.raises(TypeError):
        sorter(['5', 3, '8', 6, '2'])

# Run the tests
if __name__ == "__main__":
    pytest.main()
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.